/*
 *********************************************************************************************************
 *                                                uC/OS-II
 *                                          The Real-Time Kernel
 *                                            MEMORY MANAGEMENT
 *
 *                          (c) Copyright 1992-2006, Jean J. Labrosse, Weston, FL
 *                                           All Rights Reserved
 *
 * File    : OS_MEM.C
 * By      : Jean J. Labrosse
 * Version : V2.83
 *********************************************************************************************************
 */

#ifndef  OS_MASTER_FILE
#include <ucos_ii.h>
#endif

#if (OS_MEM_EN > 0) && (OS_MAX_MEM_PART > 0)
/*
 *********************************************************************************************************
 *                                        CREATE A MEMORY PARTITION
 *
 * Description : Create a fixed-sized memory partition that will be managed by uC/OS-II.
 *
 * Arguments   : addr     is the starting address of the memory partition
 *
 *               nblks    is the number of memory blocks to create from the partition.
 *
 *               blksize  is the size (in bytes) of each block in the memory partition.
 *
 *               err      is a pointer to a variable containing an error message which will be set by
 *                        this function to either:
 *
 *                        OS_NO_ERR            if the memory partition has been created correctly.
 *                        OS_MEM_INVALID_ADDR  you are specifying an invalid address for the memory
 *                                             storage of the partition or, the block does not align
 *                                             on a pointer boundary
 *                        OS_MEM_INVALID_PART  no free partitions available
 *                        OS_MEM_INVALID_BLKS  user specified an invalid number of blocks (must be >= 2)
 *                        OS_MEM_INVALID_SIZE  user specified an invalid block size
 *                                                - must be greater than the size of a pointer
 *                                                - must be able to hold an integral number of pointers
 * Returns    : != (OS_MEM *)0  is the partition was created
 *              == (OS_MEM *)0  if the partition was not created because of invalid arguments or, no
 *                              free partition is available.
 *********************************************************************************************************
 */

OS_MEM  *OSMemCreate(void *addr, INT32U nblks, INT32U blksize, INT8U *err)
{
    OS_MEM    *pmem;
    INT8U     *pblk;
    void     **plink;
    INT32U i;

#if OS_CRITICAL_METHOD == 3                           /* Allocate storage for CPU status register      */
    OS_CPU_SR cpu_sr = 0;
#endif



#if OS_ARG_CHK_EN > 0
    if (err == (INT8U*)0)                             /* Validate 'err'                                */
    {
        return (OS_MEM*)0;
    }
    if (addr == (void*)0)                             /* Must pass a valid address for the memory part.*/
    {
        *err = OS_MEM_INVALID_ADDR;
        return (OS_MEM*)0;
    }
    if (((INT32U)addr & (sizeof(void *) - 1)) != 0)   /* Must be pointer size aligned                  */
    {
        *err = OS_MEM_INVALID_ADDR;
        return (OS_MEM*)0;
    }
    if (nblks < 2)                                    /* Must have at least 2 blocks per partition     */
    {
        *err = OS_MEM_INVALID_BLKS;
        return (OS_MEM*)0;
    }
    if (blksize < sizeof(void *))                     /* Must contain space for at least a pointer     */
    {
        *err = OS_MEM_INVALID_SIZE;
        return (OS_MEM*)0;
    }
    if ((blksize % sizeof(void *)) != 0)              /* Must contain space for an integral number ... */
    {
        *err = OS_MEM_INVALID_SIZE;                   /* ... of pointer sized items                    */
        return (OS_MEM*)0;
    }
#endif
    OS_ENTER_CRITICAL();
    pmem = OSMemFreeList;                             /* Get next free memory partition                */
    if (OSMemFreeList != (OS_MEM*)0)                  /* See if pool of free partitions was empty      */
    {
        OSMemFreeList = (OS_MEM*)OSMemFreeList->OSMemFreeList;
    }
    OS_EXIT_CRITICAL();
    if (pmem == (OS_MEM*)0)                           /* See if we have a memory partition             */
    {
        *err = OS_MEM_INVALID_PART;
        return (OS_MEM*)0;
    }
    plink = (void**)addr;                             /* Create linked list of free memory blocks      */
    pblk  = (INT8U*)((INT32U)addr + blksize);
    for (i = 0; i < (nblks - 1); i++)
    {
        *plink = (void*)pblk;                         /* Save pointer to NEXT block in CURRENT block   */
        plink = (void**)pblk;                         /* Position to  NEXT      block                  */
        pblk  = (INT8U*)((INT32U)pblk + blksize);     /* Point to the FOLLOWING block                  */
    }
    *plink              = (void*)0;                   /* Last memory block points to NULL              */
    pmem->OSMemAddr     = addr;                       /* Store start address of memory partition       */
    pmem->OSMemFreeList = addr;                       /* Initialize pointer to pool of free blocks     */
    pmem->OSMemNFree    = nblks;                      /* Store number of free blocks in MCB            */
    pmem->OSMemNBlks    = nblks;
    pmem->OSMemBlkSize  = blksize;                    /* Store block size of each memory blocks        */
    *err                = OS_NO_ERR;
    return pmem;
}
/*$PAGE*/
/*
 *********************************************************************************************************
 *                                          GET A MEMORY BLOCK
 *
 * Description : Get a memory block from a partition
 *
 * Arguments   : pmem    is a pointer to the memory partition control block
 *
 *               err     is a pointer to a variable containing an error message which will be set by this
 *                       function to either:
 *
 *                       OS_NO_ERR           if the memory partition has been created correctly.
 *                       OS_MEM_NO_FREE_BLKS if there are no more free memory blocks to allocate to caller
 *                       OS_MEM_INVALID_PMEM if you passed a NULL pointer for 'pmem'
 *
 * Returns     : A pointer to a memory block if no error is detected
 *               A pointer to NULL if an error is detected
 *********************************************************************************************************
 */

void  *OSMemGet(OS_MEM *pmem, INT8U *err)
{
    void      *pblk;

#if OS_CRITICAL_METHOD == 3                           /* Allocate storage for CPU status register      */
    OS_CPU_SR cpu_sr = 0;
#endif



#if OS_ARG_CHK_EN > 0
    if (err == (INT8U*)0)                             /* Validate 'err'                                */
    {
        return (void*)0;
    }
    if (pmem == (OS_MEM*)0)                           /* Must point to a valid memory partition        */
    {
        *err = OS_MEM_INVALID_PMEM;
        return (void*)0;
    }
#endif
    OS_ENTER_CRITICAL();
    if (pmem->OSMemNFree > 0)                         /* See if there are any free memory blocks       */
    {
        pblk                = pmem->OSMemFreeList;    /* Yes, point to next free memory block          */
        pmem->OSMemFreeList = *(void**)pblk;          /*      Adjust pointer to new free list          */
        pmem->OSMemNFree--;                           /*      One less memory block in this partition  */
        OS_EXIT_CRITICAL();
        *err = OS_NO_ERR;                             /*      No error                                 */
        return pblk;                                  /*      Return memory block to caller            */
    }
    OS_EXIT_CRITICAL();
    *err = OS_MEM_NO_FREE_BLKS;                       /* No,  Notify caller of empty memory partition  */
    return (void*)0;                                  /*      Return NULL pointer to caller            */
}
/*$PAGE*/
/*
 *********************************************************************************************************
 *                                   GET THE NAME OF A MEMORY PARTITION
 *
 * Description: This function is used to obtain the name assigned to a memory partition.
 *
 * Arguments  : pmem      is a pointer to the memory partition
 *
 *              pname     is a pointer to an ASCII string that will receive the name of the memory partition.
 *
 *              err       is a pointer to an error code that can contain one of the following values:
 *
 *                        OS_NO_ERR                  if the name was copied to 'pname'
 *                        OS_MEM_INVALID_PMEM        if you passed a NULL pointer for 'pmem'
 *                        OS_ERR_PNAME_NULL          You passed a NULL pointer for 'pname'
 *
 * Returns    : The length of the string or 0 if 'pmem' is a NULL pointer.
 *********************************************************************************************************
 */

#if OS_MEM_NAME_SIZE > 1
INT8U  OSMemNameGet(OS_MEM *pmem, INT8U *pname, INT8U *err)
{
    INT8U len;

#if OS_CRITICAL_METHOD == 3                      /* Allocate storage for CPU status register           */
    OS_CPU_SR cpu_sr = 0;
#endif



    OS_ENTER_CRITICAL();
#if OS_ARG_CHK_EN > 0
    if (err == (INT8U*)0)                        /* Validate 'err'                                     */
    {
        OS_EXIT_CRITICAL();
        return 0;
    }
    if (pmem == (OS_MEM*)0)                      /* Is 'pmem' a NULL pointer?                          */
    {
        OS_EXIT_CRITICAL();                      /* Yes                                                */
        *err = OS_MEM_INVALID_PMEM;
        return 0;
    }
    if (pname == (INT8U*)0)                       /* Is 'pname' a NULL pointer?                         */
    {
        OS_EXIT_CRITICAL();                      /* Yes                                                */
        *err = OS_ERR_PNAME_NULL;
        return 0;
    }
#endif
    len  = OS_StrCopy(pname, pmem->OSMemName);   /* Copy name from OS_MEM                              */
    OS_EXIT_CRITICAL();
    *err = OS_NO_ERR;
    return len;
}
#endif

/*$PAGE*/
/*
 *********************************************************************************************************
 *                                 ASSIGN A NAME TO A MEMORY PARTITION
 *
 * Description: This function assigns a name to a memory partition.
 *
 * Arguments  : pmem      is a pointer to the memory partition
 *
 *              pname     is a pointer to an ASCII string that contains the name of the memory partition.
 *
 *              err       is a pointer to an error code that can contain one of the following values:
 *
 *                        OS_NO_ERR                  if the name was copied to 'pname'
 *                        OS_MEM_INVALID_PMEM        if you passed a NULL pointer for 'pmem'
 *                        OS_ERR_PNAME_NULL          You passed a NULL pointer for 'pname'
 *                        OS_MEM_NAME_TOO_LONG       if the name doesn't fit in the storage area
 *
 * Returns    : None
 *********************************************************************************************************
 */

#if OS_MEM_NAME_SIZE > 1
void  OSMemNameSet(OS_MEM *pmem, INT8U *pname, INT8U *err)
{
    INT8U len;

#if OS_CRITICAL_METHOD == 3                      /* Allocate storage for CPU status register           */
    OS_CPU_SR cpu_sr = 0;
#endif



    OS_ENTER_CRITICAL();
#if OS_ARG_CHK_EN > 0
    if (err == (INT8U*)0)                        /* Validate 'err'                                     */
    {
        OS_EXIT_CRITICAL();
        return;
    }
    if (pmem == (OS_MEM*)0)                      /* Is 'pmem' a NULL pointer?                          */
    {
        OS_EXIT_CRITICAL();                      /* Yes                                                */
        *err = OS_MEM_INVALID_PMEM;
        return;
    }
    if (pname == (INT8U*)0)                       /* Is 'pname' a NULL pointer?                         */
    {
        OS_EXIT_CRITICAL();                      /* Yes                                                */
        *err = OS_ERR_PNAME_NULL;
        return;
    }
#endif
    len = OS_StrLen(pname);                      /* Can we fit the string in the storage area?         */
    if (len > (OS_MEM_NAME_SIZE - 1))            /* No                                                 */
    {
        OS_EXIT_CRITICAL();
        *err = OS_MEM_NAME_TOO_LONG;
        return;
    }
    (void)OS_StrCopy(pmem->OSMemName, pname);    /* Yes, copy name to the memory partition header      */
    OS_EXIT_CRITICAL();
    *err = OS_NO_ERR;
}
#endif

/*$PAGE*/
/*
 *********************************************************************************************************
 *                                         RELEASE A MEMORY BLOCK
 *
 * Description : Returns a memory block to a partition
 *
 * Arguments   : pmem    is a pointer to the memory partition control block
 *
 *               pblk    is a pointer to the memory block being released.
 *
 * Returns     : OS_NO_ERR            if the memory block was inserted into the partition
 *               OS_MEM_FULL          if you are returning a memory block to an already FULL memory
 *                                    partition (You freed more blocks than you allocated!)
 *               OS_MEM_INVALID_PMEM  if you passed a NULL pointer for 'pmem'
 *               OS_MEM_INVALID_PBLK  if you passed a NULL pointer for the block to release.
 *********************************************************************************************************
 */

INT8U  OSMemPut(OS_MEM *pmem, void *pblk)
{
#if OS_CRITICAL_METHOD == 3                      /* Allocate storage for CPU status register           */
    OS_CPU_SR cpu_sr = 0;
#endif



#if OS_ARG_CHK_EN > 0
    if (pmem == (OS_MEM*)0)                      /* Must point to a valid memory partition             */
    {
        return OS_MEM_INVALID_PMEM;
    }
    if (pblk == (void*)0)                        /* Must release a valid block                         */
    {
        return OS_MEM_INVALID_PBLK;
    }
#endif
    OS_ENTER_CRITICAL();
    if (pmem->OSMemNFree >= pmem->OSMemNBlks)    /* Make sure all blocks not already returned          */
    {
        OS_EXIT_CRITICAL();
        return OS_MEM_FULL;
    }
    *(void**)pblk      = pmem->OSMemFreeList;    /* Insert released block into free block list         */
    pmem->OSMemFreeList = pblk;
    pmem->OSMemNFree++;                          /* One more memory block in this partition            */
    OS_EXIT_CRITICAL();
    return OS_NO_ERR;                            /* Notify caller that memory block was released       */
}
/*$PAGE*/
/*
 *********************************************************************************************************
 *                                          QUERY MEMORY PARTITION
 *
 * Description : This function is used to determine the number of free memory blocks and the number of
 *               used memory blocks from a memory partition.
 *
 * Arguments   : pmem        is a pointer to the memory partition control block
 *
 *               p_mem_data  is a pointer to a structure that will contain information about the memory
 *                           partition.
 *
 * Returns     : OS_NO_ERR            If no errors were found.
 *               OS_MEM_INVALID_PMEM  if you passed a NULL pointer for 'pmem'
 *               OS_MEM_INVALID_PDATA if you passed a NULL pointer to the data recipient.
 *********************************************************************************************************
 */

#if OS_MEM_QUERY_EN > 0
INT8U  OSMemQuery(OS_MEM *pmem, OS_MEM_DATA *p_mem_data)
{
#if OS_CRITICAL_METHOD == 3                      /* Allocate storage for CPU status register           */
    OS_CPU_SR cpu_sr = 0;
#endif



#if OS_ARG_CHK_EN > 0
    if (pmem == (OS_MEM*)0)                      /* Must point to a valid memory partition             */
    {
        return OS_MEM_INVALID_PMEM;
    }
    if (p_mem_data == (OS_MEM_DATA*)0)           /* Must release a valid storage area for the data     */
    {
        return OS_MEM_INVALID_PDATA;
    }
#endif
    OS_ENTER_CRITICAL();
    p_mem_data->OSAddr     = pmem->OSMemAddr;
    p_mem_data->OSFreeList = pmem->OSMemFreeList;
    p_mem_data->OSBlkSize  = pmem->OSMemBlkSize;
    p_mem_data->OSNBlks    = pmem->OSMemNBlks;
    p_mem_data->OSNFree    = pmem->OSMemNFree;
    OS_EXIT_CRITICAL();
    p_mem_data->OSNUsed    = p_mem_data->OSNBlks - p_mem_data->OSNFree;
    return OS_NO_ERR;
}
#endif                                           /* OS_MEM_QUERY_EN                                    */
/*$PAGE*/
/*
 *********************************************************************************************************
 *                                    INITIALIZE MEMORY PARTITION MANAGER
 *
 * Description : This function is called by uC/OS-II to initialize the memory partition manager.  Your
 *               application MUST NOT call this function.
 *
 * Arguments   : none
 *
 * Returns     : none
 *
 * Note(s)    : This function is INTERNAL to uC/OS-II and your application should not call it.
 *********************************************************************************************************
 */

void  OS_MemInit(void)
{
#if OS_MAX_MEM_PART == 1
    OS_MemClr((INT8U*)&OSMemTbl[0], sizeof(OSMemTbl));    /* Clear the memory partition table          */
    OSMemFreeList               = (OS_MEM*)&OSMemTbl[0];  /* Point to beginning of free list           */
#if OS_MEM_NAME_SIZE > 1
    OSMemFreeList->OSMemName[0] = '?';                    /* Unknown name                              */
    OSMemFreeList->OSMemName[1] = OS_ASCII_NUL;
#endif
#endif

#if OS_MAX_MEM_PART >= 2
    OS_MEM  *pmem;
    INT16U i;


    OS_MemClr((INT8U*)&OSMemTbl[0], sizeof(OSMemTbl));    /* Clear the memory partition table          */
    pmem = &OSMemTbl[0];                                  /* Point to memory control block (MCB)       */
    for (i = 0; i < (OS_MAX_MEM_PART - 1); i++)           /* Init. list of free memory partitions      */
    {
        pmem->OSMemFreeList = (void*)&OSMemTbl[i + 1];     /* Chain list of free partitions             */
#if OS_MEM_NAME_SIZE > 1
        pmem->OSMemName[0]  = '?';                        /* Unknown name                              */
        pmem->OSMemName[1]  = OS_ASCII_NUL;
#endif
        pmem++;
    }
    pmem->OSMemFreeList = (void*)0;                       /* Initialize last node                      */
#if OS_MEM_NAME_SIZE > 1
    pmem->OSMemName[0]  = '?';                            /* Unknown name                              */
    pmem->OSMemName[1]  = OS_ASCII_NUL;
#endif

    OSMemFreeList       = &OSMemTbl[0];                   /* Point to beginning of free list           */
#endif
}
#endif                                                    /* OS_MEM_EN                                 */
